/*     */ package com.zimbra.cs.service;
/*     */ 
/*     */ import com.google.common.base.Strings;
/*     */ import com.zimbra.common.account.Key.AccountBy;
/*     */ import com.zimbra.common.localconfig.KnownKey;
/*     */ import com.zimbra.common.localconfig.LC;
/*     */ import com.zimbra.common.service.ServiceException;
/*     */ import com.zimbra.common.soap.Element;
/*     */ import com.zimbra.common.util.Log;
/*     */ import com.zimbra.common.util.LogFactory;
/*     */ import com.zimbra.common.util.ZimbraLog;
/*     */ import com.zimbra.cs.account.Account;
/*     */ import com.zimbra.cs.account.AuthToken;
/*     */ import com.zimbra.cs.account.AuthTokenException;
/*     */ import com.zimbra.cs.account.Provisioning;
/*     */ import com.zimbra.cs.account.auth.AuthMechanism.AuthMech;
/*     */ import com.zimbra.cs.service.admin.AdminAccessControl;
/*     */ import com.zimbra.cs.servlet.ZimbraServlet;
/*     */ import java.util.ArrayList;
/*     */ import java.util.HashMap;
/*     */ import java.util.List;
/*     */ import java.util.Map;
/*     */ import javax.servlet.http.HttpServletRequest;
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ public abstract class AuthProvider
/*     */ {
/*  45 */   private static Log sLog = LogFactory.getLog(AuthProvider.class);
/*     */   
/*     */ 
/*  48 */   private static Map<String, AuthProvider> registeredProviders = new HashMap();
/*     */   
/*     */ 
/*  51 */   private static List<AuthProvider> enabledProviders = null;
/*     */   private String mName;
/*     */   
/*  54 */   static { register(new ZimbraAuthProvider());
/*     */     
/*  56 */     refresh();
/*     */   }
/*     */   
/*     */   public static synchronized void register(AuthProvider ap) {
/*  60 */     String name = ap.getName();
/*  61 */     logger().info("Adding auth provider: " + name + " " + ap.getClass().getName());
/*     */     
/*  63 */     if (registeredProviders.get(name) == null) {
/*  64 */       registeredProviders.put(name, ap);
/*     */     } else {
/*  66 */       logger().error("auth provider " + name + " already exists, not adding " + ap.getClass().getName());
/*     */     }
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   public static void refresh()
/*     */   {
/*  77 */     List<AuthProvider> providerList = new ArrayList();
/*  78 */     String[] providers = LC.zimbra_auth_provider.value().split(",");
/*  79 */     for (String provider : providers)
/*     */     {
/*  81 */       provider = provider.trim();
/*  82 */       if (!Strings.isNullOrEmpty(provider)) {
/*  83 */         AuthProvider ap = (AuthProvider)registeredProviders.get(provider);
/*  84 */         if (ap != null) {
/*  85 */           providerList.add(ap);
/*     */         }
/*     */       }
/*     */     }
/*     */     
/*     */ 
/*  91 */     if (providerList.size() == 0) {
/*  92 */       providerList.add(registeredProviders.get("zimbra"));
/*     */     }
/*     */     
/*     */ 
/*  96 */     setProviders(providerList);
/*     */   }
/*     */   
/*     */   private static synchronized void setProviders(List<AuthProvider> providers) {
/* 100 */     enabledProviders = providers;
/*     */   }
/*     */   
/*     */   private static synchronized List<AuthProvider> getProviders() {
/* 104 */     return enabledProviders;
/*     */   }
/*     */   
/*     */ 
/*     */   protected AuthProvider(String name)
/*     */   {
/* 110 */     this.mName = name;
/*     */   }
/*     */   
/*     */   private String getName() {
/* 114 */     return this.mName;
/*     */   }
/*     */   
/*     */   protected static Log logger() {
/* 118 */     return sLog;
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   protected AuthToken authToken(Element authTokenElem, Account acct)
/*     */     throws AuthProviderException, AuthTokenException
/*     */   {
/* 169 */     String token = authTokenElem.getText();
/* 170 */     return authToken(token);
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   protected AuthToken authToken(String encoded)
/*     */     throws AuthProviderException, AuthTokenException
/*     */   {
/* 196 */     throw AuthProviderException.NOT_SUPPORTED();
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   protected AuthToken authToken(Account acct)
/*     */     throws AuthProviderException
/*     */   {
/* 208 */     return authToken(acct, false, null);
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   protected AuthToken authToken(Account acct, boolean isAdmin, AuthMechanism.AuthMech authMech)
/*     */     throws AuthProviderException
/*     */   {
/* 223 */     if (acct == null) {
/* 224 */       throw AuthProviderException.NOT_SUPPORTED();
/*     */     }
/*     */     
/* 227 */     long lifetime = isAdmin ? acct.getTimeInterval("zimbraAdminAuthTokenLifetime", 43200000L) : acct.getTimeInterval("zimbraAuthTokenLifetime", 43200000L);
/*     */     
/*     */ 
/*     */ 
/*     */ 
/* 232 */     return authToken(acct, lifetime);
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   protected AuthToken authToken(Account acct, long expires)
/*     */     throws AuthProviderException
/*     */   {
/* 245 */     throw AuthProviderException.NOT_SUPPORTED();
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   protected AuthToken authToken(Account acct, long expires, boolean isAdmin, Account adminAcct)
/*     */     throws AuthProviderException
/*     */   {
/* 267 */     throw AuthProviderException.NOT_SUPPORTED();
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   protected boolean allowHttpBasicAuth(HttpServletRequest req, ZimbraServlet servlet)
/*     */   {
/* 276 */     return true;
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   protected boolean allowURLAccessKeyAuth(HttpServletRequest req, ZimbraServlet servlet)
/*     */   {
/* 285 */     return false;
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   public static AuthToken getAuthToken(HttpServletRequest req, boolean isAdminReq)
/*     */     throws AuthTokenException
/*     */   {
/* 316 */     AuthToken at = null;
/* 317 */     List<AuthProvider> providers = getProviders();
/* 318 */     for (AuthProvider ap : providers) {
/*     */       try {
/* 320 */         at = ap.authToken(req, isAdminReq);
/* 321 */         if (at == null) {
/* 322 */           throw new AuthTokenException("auth provider " + ap.getName() + " returned null");
/*     */         }
/* 324 */         return at;
/*     */       }
/*     */       catch (AuthProviderException e)
/*     */       {
/* 328 */         if (e.canIgnore()) {
/* 329 */           logger().debug(ap.getName() + ":" + e.getMessage());
/*     */         } else {
/* 331 */           throw new AuthTokenException("auth provider error", e);
/*     */         }
/*     */       }
/*     */       catch (AuthTokenException e) {
/* 335 */         logger().debug("getAuthToken error: provider=" + ap.getName() + ", err=" + e.getMessage(), e);
/* 336 */         throw e;
/*     */       }
/*     */     }
/*     */     
/*     */ 
/* 341 */     return null;
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   public static AuthToken getAuthToken(Element soapCtxt, Map engineCtxt)
/*     */     throws AuthTokenException
/*     */   {
/* 359 */     AuthToken at = null;
/* 360 */     List<AuthProvider> providers = getProviders();
/* 361 */     for (AuthProvider ap : providers) {
/*     */       try {
/* 363 */         at = ap.authToken(soapCtxt, engineCtxt);
/* 364 */         if (at == null) {
/* 365 */           throw new AuthTokenException("auth provider " + ap.getName() + " returned null");
/*     */         }
/* 367 */         return at;
/*     */       }
/*     */       catch (AuthProviderException e)
/*     */       {
/* 371 */         if (e.canIgnore()) {
/* 372 */           logger().debug(ap.getName() + ":" + e.getMessage());
/*     */         } else {
/* 374 */           throw new AuthTokenException("auth provider error", e);
/*     */         }
/*     */       }
/*     */       catch (AuthTokenException e) {
/* 378 */         logger().debug("getAuthToken error: provider=" + ap.getName() + ", err=" + e.getMessage(), e);
/* 379 */         throw e;
/*     */       }
/*     */     }
/*     */     
/*     */ 
/* 384 */     return null;
/*     */   }
/*     */   
/*     */   public static AuthToken getAuthToken(Element authTokenElem, Account acct) throws AuthTokenException
/*     */   {
/* 389 */     AuthToken at = null;
/* 390 */     List<AuthProvider> providers = getProviders();
/* 391 */     for (AuthProvider ap : providers) {
/*     */       try {
/* 393 */         at = ap.authToken(authTokenElem, acct);
/* 394 */         if (at == null) {
/* 395 */           throw new AuthTokenException("auth provider " + ap.getName() + " returned null");
/*     */         }
/* 397 */         return at;
/*     */       }
/*     */       catch (AuthProviderException e)
/*     */       {
/* 401 */         if (e.canIgnore()) {
/* 402 */           logger().debug(ap.getName() + ":" + e.getMessage());
/*     */         } else {
/* 404 */           throw new AuthTokenException("auth provider error", e);
/*     */         }
/*     */       }
/*     */       catch (AuthTokenException e) {
/* 408 */         logger().debug("getAuthToken error: provider=" + ap.getName() + ", err=" + e.getMessage(), e);
/* 409 */         throw e;
/*     */       }
/*     */     }
/*     */     
/*     */ 
/* 414 */     return null;
/*     */   }
/*     */   
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   public static AuthToken getAuthToken(String encoded)
/*     */     throws AuthTokenException
/*     */   {
/* 426 */     AuthToken at = null;
/* 427 */     List<AuthProvider> providers = getProviders();
/* 428 */     for (AuthProvider ap : providers) {
/*     */       try {
/* 430 */         at = ap.authToken(encoded);
/* 431 */         if (at == null) {
/* 432 */           throw new AuthTokenException("auth provider " + ap.getName() + " returned null");
/*     */         }
/* 434 */         return at;
/*     */       }
/*     */       catch (AuthProviderException e)
/*     */       {
/* 438 */         if (e.canIgnore()) {
/* 439 */           logger().warn(ap.getName() + ":" + e.getMessage());
/*     */         } else {
/* 441 */           throw new AuthTokenException("auth provider error", e);
/*     */         }
/*     */       }
/*     */       catch (AuthTokenException e) {
/* 445 */         logger().debug("getAuthToken error: provider=" + ap.getName() + ", err=" + e.getMessage(), e);
/* 446 */         throw e;
/*     */       }
/*     */     }
/*     */     
/*     */ 
/* 451 */     logger().error("unable to get AuthToken from encoded " + encoded);
/* 452 */     return null;
/*     */   }
/*     */   
/*     */   public static AuthToken getAuthToken(Account acct) throws AuthProviderException {
/* 456 */     List<AuthProvider> providers = getProviders();
/* 457 */     for (AuthProvider ap : providers) {
/*     */       try {
/* 459 */         AuthToken at = ap.authToken(acct);
/* 460 */         if (at == null) {
/* 461 */           throw AuthProviderException.FAILURE("auth provider " + ap.getName() + " returned null");
/*     */         }
/* 463 */         return at;
/*     */       }
/*     */       catch (AuthProviderException e) {
/* 466 */         if (e.canIgnore()) {
/* 467 */           logger().debug(ap.getName() + ":" + e.getMessage());
/*     */         } else {
/* 469 */           throw e;
/*     */         }
/*     */       }
/*     */     }
/*     */     
/* 474 */     throw AuthProviderException.FAILURE("cannot get authtoken from account " + acct.getName());
/*     */   }
/*     */   
/*     */   public static AuthToken getAuthToken(Account acct, boolean isAdmin) throws AuthProviderException
/*     */   {
/* 479 */     return getAuthToken(acct, isAdmin, null);
/*     */   }
/*     */   
/*     */   public static AuthToken getAuthToken(Account acct, boolean isAdmin, AuthMechanism.AuthMech authMech) throws AuthProviderException
/*     */   {
/* 484 */     List<AuthProvider> providers = getProviders();
/* 485 */     for (AuthProvider ap : providers) {
/*     */       try {
/* 487 */         AuthToken at = ap.authToken(acct, isAdmin, authMech);
/* 488 */         if (at == null) {
/* 489 */           throw AuthProviderException.FAILURE("auth provider " + ap.getName() + " returned null");
/*     */         }
/* 491 */         return at;
/*     */       }
/*     */       catch (AuthProviderException e) {
/* 494 */         if (e.canIgnore()) {
/* 495 */           logger().debug(ap.getName() + ":" + e.getMessage());
/*     */         } else {
/* 497 */           throw e;
/*     */         }
/*     */       }
/*     */     }
/*     */     
/* 502 */     String acctName = acct != null ? acct.getName() : "null";
/* 503 */     throw AuthProviderException.FAILURE("cannot get authtoken from account " + acctName);
/*     */   }
/*     */   
/*     */   public static AuthToken getAdminAuthToken() throws ServiceException {
/* 507 */     Account acct = Provisioning.getInstance().get(Key.AccountBy.adminName, LC.zimbra_ldap_user.value());
/* 508 */     return getAuthToken(acct, true);
/*     */   }
/*     */   
/*     */   public static AuthToken getAuthToken(Account acct, long expires) throws AuthProviderException {
/* 512 */     List<AuthProvider> providers = getProviders();
/* 513 */     for (AuthProvider ap : providers) {
/*     */       try {
/* 515 */         AuthToken at = ap.authToken(acct, expires);
/* 516 */         if (at == null) {
/* 517 */           throw AuthProviderException.FAILURE("auth provider " + ap.getName() + " returned null");
/*     */         }
/* 519 */         return at;
/*     */       }
/*     */       catch (AuthProviderException e) {
/* 522 */         if (e.canIgnore()) {
/* 523 */           logger().debug(ap.getName() + ":" + e.getMessage());
/*     */         } else {
/* 525 */           throw e;
/*     */         }
/*     */       }
/*     */     }
/*     */     
/* 530 */     throw AuthProviderException.FAILURE("cannot get authtoken from account " + acct.getName());
/*     */   }
/*     */   
/*     */   public static AuthToken getAuthToken(Account acct, long expires, boolean isAdmin, Account adminAcct) throws AuthProviderException
/*     */   {
/* 535 */     List<AuthProvider> providers = getProviders();
/* 536 */     for (AuthProvider ap : providers) {
/*     */       try {
/* 538 */         AuthToken at = ap.authToken(acct, expires, isAdmin, adminAcct);
/* 539 */         if (at == null) {
/* 540 */           throw AuthProviderException.FAILURE("auth provider " + ap.getName() + " returned null");
/*     */         }
/* 542 */         return at;
/*     */       }
/*     */       catch (AuthProviderException e) {
/* 545 */         if (e.canIgnore()) {
/* 546 */           logger().debug(ap.getName() + ":" + e.getMessage());
/*     */         } else {
/* 548 */           throw e;
/*     */         }
/*     */       }
/*     */     }
/*     */     
/* 553 */     throw AuthProviderException.FAILURE("cannot get authtoken from account " + acct.getName());
/*     */   }
/*     */   
/*     */   public static boolean allowBasicAuth(HttpServletRequest req, ZimbraServlet servlet) {
/* 557 */     List<AuthProvider> providers = getProviders();
/* 558 */     for (AuthProvider ap : providers) {
/* 559 */       if (ap.allowHttpBasicAuth(req, servlet)) {
/* 560 */         return true;
/*     */       }
/*     */     }
/* 563 */     return false;
/*     */   }
/*     */   
/*     */   public static boolean allowAccessKeyAuth(HttpServletRequest req, ZimbraServlet servlet) {
/* 567 */     List<AuthProvider> providers = getProviders();
/* 568 */     for (AuthProvider ap : providers) {
/* 569 */       if (ap.allowURLAccessKeyAuth(req, servlet)) {
/* 570 */         return true;
/*     */       }
/*     */     }
/* 573 */     return false;
/*     */   }
/*     */   
/*     */   public static Account validateAuthToken(Provisioning prov, AuthToken at, boolean addToLoggingContext) throws ServiceException
/*     */   {
/*     */     try {
/* 579 */       return validateAuthTokenInternal(prov, at, addToLoggingContext);
/*     */     } catch (ServiceException e) {
/* 581 */       if ("service.AUTH_EXPIRED".equals(e.getCode()))
/*     */       {
/*     */ 
/* 584 */         ZimbraLog.account.debug("auth token validation failed", e);
/* 585 */         throw ServiceException.AUTH_EXPIRED();
/*     */       }
/*     */       
/* 588 */       throw e;
/*     */     }
/*     */   }
/*     */   
/*     */   private static Account validateAuthTokenInternal(Provisioning prov, AuthToken at, boolean addToLoggingContext)
/*     */     throws ServiceException
/*     */   {
/* 595 */     if (prov == null) {
/* 596 */       prov = Provisioning.getInstance();
/*     */     }
/*     */     
/* 599 */     if (at.isExpired()) {
/* 600 */       if (at.isRegistered()) {
/*     */         try {
/* 602 */           at.deRegister();
/*     */         } catch (AuthTokenException e) {
/* 604 */           ZimbraLog.account.error(e);
/*     */         }
/*     */       }
/* 607 */       throw ServiceException.AUTH_EXPIRED();
/*     */     }
/*     */     
/* 610 */     if (!at.isRegistered()) {
/* 611 */       throw ServiceException.AUTH_EXPIRED();
/*     */     }
/*     */     
/* 614 */     String acctId = at.getAccountId();
/* 615 */     Account acct = prov.get(Key.AccountBy.id, acctId, at);
/*     */     
/* 617 */     if (acct == null) {
/* 618 */       throw ServiceException.AUTH_EXPIRED("account " + acctId + " not found");
/*     */     }
/*     */     
/* 621 */     if (addToLoggingContext) {
/* 622 */       ZimbraLog.addAccountNameToContext(acct.getName());
/*     */     }
/*     */     
/* 625 */     if (!acct.checkAuthTokenValidityValue(at)) {
/* 626 */       throw ServiceException.AUTH_EXPIRED("invalid validity value");
/*     */     }
/*     */     
/* 629 */     boolean delegatedAuth = at.isDelegatedAuth();
/* 630 */     String acctStatus = acct.getAccountStatus(prov);
/*     */     
/* 632 */     if ((!delegatedAuth) && (!"active".equals(acctStatus))) {
/* 633 */       throw ServiceException.AUTH_EXPIRED("account not active");
/*     */     }
/*     */     
/*     */ 
/* 637 */     if (delegatedAuth)
/*     */     {
/*     */ 
/* 640 */       if ("maintenance".equals(acctStatus)) {
/* 641 */         throw ServiceException.AUTH_EXPIRED("delegated account in MAINTENANCE mode");
/*     */       }
/*     */       
/* 644 */       Account admin = prov.get(Key.AccountBy.id, at.getAdminAccountId());
/* 645 */       if (admin == null) {
/* 646 */         throw ServiceException.AUTH_EXPIRED("delegating account " + at.getAdminAccountId() + " not found");
/*     */       }
/*     */       
/* 649 */       boolean isAdmin = AdminAccessControl.isAdequateAdminAccount(admin);
/* 650 */       if (!isAdmin) {
/* 651 */         throw ServiceException.PERM_DENIED("not an admin for delegated auth");
/*     */       }
/*     */       
/* 654 */       if (!"active".equals(admin.getAccountStatus(prov))) {
/* 655 */         throw ServiceException.AUTH_EXPIRED("delegating account is not active");
/*     */       }
/*     */     }
/*     */     
/* 659 */     return acct;
/*     */   }
/*     */   
/*     */   protected abstract AuthToken authToken(HttpServletRequest paramHttpServletRequest, boolean paramBoolean)
/*     */     throws AuthProviderException, AuthTokenException;
/*     */   
/*     */   protected abstract AuthToken authToken(Element paramElement, Map paramMap)
/*     */     throws AuthProviderException, AuthTokenException;
/*     */ }


/* Location:              /home/mint/zimbrastore.jar!/com/zimbra/cs/service/AuthProvider.class
 * Java compiler version: 7 (51.0)
 * JD-Core Version:       0.7.1
 */